import io from 'socket.io-client';

    /**
     * Socket.IO客户端工具，提供非Hook环境下的Socket.IO功能
     */

    // Socket.IO服务器URL配置
    const SOCKET_URL = process.env.NODE_ENV === 'production' 
      ? 'https://api.example.com' 
      : 'http://localhost:3001';

    class SocketIOClient {
      constructor(namespace = '') {
        this.namespace = namespace;
        this.socket = null;
        this.isConnected = false;
        this.eventHandlers = {};
        this.options = {
          reconnection: true,
          reconnectionAttempts: 5,
          reconnectionDelay: 1000,
          reconnectionDelayMax: 5000,
          timeout: 20000,
        };
      }

      /**
       * 设置连接选项
       * @param {Object} options - Socket.IO连接选项
       */
      setOptions(options) {
        this.options = {
          ...this.options,
          ...options,
        };
        return this;
      }

      /**
       * 连接到Socket.IO服务器
       * @returns {Promise<void>} 连接成功或失败的Promise
       */
      connect() {
        return new Promise((resolve, reject) => {
          // 如果已经连接，先关闭
          if (this.socket && this.socket.connected) {
            this.socket.disconnect();
          }

          try {
            // 构建Socket.IO URL和选项
            const url = this.namespace ? `${SOCKET_URL}/${this.namespace}` : SOCKET_URL;
            
            // 添加token（如果有）到auth对象
            const token = localStorage.getItem('authToken');
            const auth = token ? { token } : {};
            
            // 创建Socket.IO连接
            this.socket = io(url, {
              ...this.options,
              auth,
            });
            
            // 设置事件处理器
            this.socket.on('connect', () => {
              this.isConnected = true;
              console.log('Socket.IO连接已建立');
              resolve();
            });
            
            this.socket.on('disconnect', (reason) => {
              this.isConnected = false;
              console.log(`Socket.IO连接已断开: ${reason}`);
            });
            
            this.socket.on('connect_error', (err) => {
              console.error('Socket.IO连接错误:', err);
              reject(err);
            });
            
            // 注册已保存的事件处理器
            Object.entries(this.eventHandlers).forEach(([event, handlers]) => {
              handlers.forEach(handler => {
                this.socket.on(event, handler);
              });
            });
          } catch (err) {
            console.error('Socket.IO连接失败:', err);
            reject(err);
          }
        });
      }

      /**
       * 发送事件到Socket.IO服务器
       * @param {string} event - 事件名称
       * @param {any} data - 事件数据
       * @param {Function} callback - 可选的回调函数
       * @returns {boolean} 是否发送成功
       */
      emit(event, data, callback) {
        if (this.socket && this.socket.connected) {
          if (callback) {
            this.socket.emit(event, data, callback);
          } else {
            this.socket.emit(event, data);
          }
          return true;
        } else {
          console.error('Socket.IO未连接，无法发送事件');
          return false;
        }
      }

      /**
       * 添加事件监听器
       * @param {string} event - 事件名称
       * @param {Function} handler - 处理函数
       * @returns {Function} 用于移除处理函数的函数
       */
      on(event, handler) {
        // 保存处理函数
        if (!this.eventHandlers[event]) {
          this.eventHandlers[event] = [];
        }
        this.eventHandlers[event].push(handler);
        
        // 如果socket已连接，立即添加监听器
        if (this.socket) {
          this.socket.on(event, handler);
        }
        
        // 返回一个函数，用于移除此处理函数
        return () => this.off(event, handler);
      }

      /**
       * 移除事件监听器
       * @param {string} event - 事件名称
       * @param {Function} handler - 处理函数
       */
      off(event, handler) {
        // 从保存的处理函数中移除
        if (this.eventHandlers[event]) {
          this.eventHandlers[event] = this.eventHandlers[event].filter(h => h !== handler);
          if (this.eventHandlers[event].length === 0) {
            delete this.eventHandlers[event];
          }
        }
        
        // 如果socket已连接，移除监听器
        if (this.socket) {
          this.socket.off(event, handler);
        }
      }

      /**
       * 一次性事件监听器
       * @param {string} event - 事件名称
       * @param {Function} handler - 处理函数
       */
      once(event, handler) {
        if (this.socket) {
          this.socket.once(event, handler);
        }
      }

      /**
       * 监听任何事件
       * @param {Function} handler - 处理函数
       * @returns {Function} 用于移除处理函数的函数
       */
      onAny(handler) {
        if (this.socket) {
          this.socket.onAny(handler);
        }
        
        // 保存处理函数
        if (!this.eventHandlers['*any*']) {
          this.eventHandlers['*any*'] = [];
        }
        this.eventHandlers['*any*'].push(handler);
        
        // 返回一个函数，用于移除此处理函数
        return () => {
          if (this.socket) {
            this.socket.offAny(handler);
          }
          
          if (this.eventHandlers['*any*']) {
            this.eventHandlers['*any*'] = this.eventHandlers['*any*'].filter(h => h !== handler);
            if (this.eventHandlers['*any*'].length === 0) {
              delete this.eventHandlers['*any*'];
            }
          }
        };
      }

      /**
       * 断开Socket.IO连接
       */
      disconnect() {
        if (this.socket) {
          this.socket.disconnect();
          this.socket = null;
        }
        this.isConnected = false;
        console.log('Socket.IO连接已断开');
      }
    }

    // 创建默认实例
    const socketIOClient = new SocketIOClient();

    export default socketIOClient;
    export { SocketIOClient };
